#include <stdbool.h>

#if 0
/*Creates an empty list without any elements*/
list<Elem> c 

/*Creates a copy of another list of the same type(all elements are copied)*/
list<Elem> c1(c2) 

/*Creates a list with n elements that are created by the default constructor*/
list<Elem> c(n) 

/*Creates a list initialized with n copies of element elem*/
list<Elem> c(n,elem) 

/*Creates a list initialized with the elements of the range [beg,end)*/
list<Elem> c(beg,end)

/*Destroys all elements and frees the memory*/
c.~list<Elem>() 
#endif

/*Returns the actual number of elements*/
inline int c.size(){
	return;
}

/*Returns whether the container is empty(equivalent to size()==0, but might be faster)*/
inline bool c.empty(){

	return;
}

/*Returns the maximum number of elements possible*/
inline int c.max_size(){

	return ;
}

#if 0
/*Returns whether c1 is equal to c2*/
c1 == c2 

/*Returns whether c1 is not equal to c2(equivalent to !(c1==c2))*/
c1 != c2 

/*Returns whether c1 is less than c2*/
c1 < c2 

/*Returns whether c1 is greater than c2(equivalent to c2<c1)*/
c1 > c2

/*Returns whether c1 is less than or equal to c2(equivalent to !(c2<c1) )*/
c1 <= c2 

/*Returns whether c1 is greater than or equal to c2(equivalent to !(c1<c2))*/
c1 >= c2 

/*Assigns all elements of c2 to c1*/
c1 = c2 
#endif

/*Assigns n copies of element elem*/
inline bool c.assign(n,elem){
	return ;
}

/*Assigns the elements of the range [beg,end)*/
inline bool c.assign(beg,end){
	return;
}

/*Swaps the data of c1 and c2*/
inline bool c1.swap(c2){
	return;
}

/*Same(as global function)*/
inline bool swap(c1,c2) {
	return;
}

/*Returns the first element(no check whether a first element exists)*/
inline c.front() {
	return;
}

/*Returns the last element(no check whether a last element exists)*/
inline c.back(){
	return;
}

/*Returns a bidirectional iterator for the first element*/
inline c.begin(){
	return;
}

/*Returns a bidirectional iterator for the position after the last element*/
inline c.end(){
	return;
}

/*Returns a reverse iterator for the first element of a reverse iteration*/
inline c.rbegin(){
	return;
}

/*Returns a reverse iterator for the position after the last element of a reverse iteration*/
inline c.rend(){
	return;
}

/*Inserts at iterator position pos a copy of elem and returns the position of the new element*/
inline c.insert(pos, elem){
	return;
}

/*Inserts at iterator position pos n copies of elem(returns nothing)*/
inline c.insert(pos,n,elem){
	return;
}

/*Inserts at iterator position pos a copy of all elements of the range(beg,end)(returns nothing)*/
inline c.insert(pos,beg,end){
	return;
}

/*Appends a copy of elem at the end*/
inline c.push_back(elem){
	return;
}

/*Removes the last element(does not return it)*/
inline bool c.pop_back(){
	return;
}

/*Inserts a copy of elem at the beginning*/
inline bool c.push_front(elem){
	return;
}

/*Removes the first element(does not return it)*/
inline bool c.pop_front(){
	return;
}

/*Removes all elements with value val*/
inline bool c.remove(val){
	return;
}

/*Removes all elements for which op(elem) yields true*/
inline bool c.remove_if(op){
	return;
}

/*Removes the element at iterator position pos and returns the position of the next element*/
inline bool c.erase(pos){
	return;
}

/*Removes all elements of the range [beg,end) and returns the position of the next element*/
inline bool c.erase(beg,end){
	return;
}

/*Changes the number of elements to num(if size() grows, 
new elements are created by their default constructor)*/
inline bool c.resize(num){
	return;
}

/*Changes the number of elements to num(if size( ) grows, 
new elements are copies of elem)*/
inline bool c.resize(num, elem){
	return;
}

/*Removes all elements(makes the container empty) Operation Effect*/
c.clear() 

/*Removes duplicates of consecutive elements with the same value*/
c.unique() 

/*Removes duplicates of consecutive elements, for which op() yields true*/
c.unique(op) 

/*Moves all elements of c2 to c1 in front of the iterator position pos*/
c1.splice(pos,c2) 

/*Moves the element at c2pos in c2 in front of pos of list c1(c1 and c2 may be identical)*/
c1.splice(pos,c2,c2pos) 

/*Moves all elements of the range [c2beg,c2end) in c2 in front of pos of list c1(c1 and c2 may be identical)*/
c1.splice(pos,c2,c2beg,c2end) 

/*Sorts all elements with operator <*/
c.sort() 

/*Sorts all elements with op()*/
c.sort(op) 

/*Assuming both containers contain the elements sorted,
moves all elements of c2 into c1 so that all elements are merged and still sorted*/
c1.merge(c2) 

/*Assuming both containers contain the elements sorted due to the sorting criterion op(), 
moves all elements of c2 into c1 so that all elements are merged and still sorted according to op()*/
c1.merge(c2,op) 

/*Reverses the order of all elements*/
c.reverse()
